// 分组的功能
; (function () {
    return
    // 我们知道 / a + / 匹配连续出现的 "a"，
    // 而要匹配连续出现的 "ab" 时，需要使用 /(ab) + /。
    // 其中括号是提供分组功能，
    // 使量词 + 作用于 "ab" 这个整体，测试如下：
    var regex = /(ab)+/g;
    var string = "ababa abbb ababab";
    console.log(string.match(regex));
    // => ["abab", "ab", "ababab"]
})();

// 分组的引用
; (function () {
    return
    // match方法
    // var regex = /(\d{4})-(\d{2})-(\d{2})/;
    // var string = "2017-06-12";
    // console.log(string.match(regex));
    // => ["2017-06-12", "2017", "06", "12", index: 0, input: "2017-06-12"]

    // exec方法
    var regex = /(\d{4})-(\d{2})-(\d{2})/;
    var string = "2017-06-12";
    // console.log(regex.exec(string));
    // => ["2017-06-12", "2017", "06", "12", index: 0, input: "2017-06-12"]


    // 正则操作即可，例如
    let result = regex.exec(string)
    // console.log(result[1]);
    console.log(RegExp.$1); // "2017"
    console.log(RegExp.$2); // "06"
    console.log(RegExp.$3); // "12"



    // 得到了分组的引用后, 可以进行替换=================================
    var regex2 = /(\d{4})-(\d{2})-(\d{2})/;
    var string2 = "2017-06-12";
    var result2 = string2.replace(regex2, "$2/$3/$1");
    console.log(result2);
    // => "06/12/2017"

    // 替换方式2
    // var regex = /(\d{4})-(\d{2})-(\d{2})/;
    // var string = "2017-06-12";
    // var result = string.replace(regex, function () {
    //     return RegExp.$2 + "/" + RegExp.$3 + "/" + RegExp.$1;
    // });
    // console.log(result);
    // // => "06/12/2017"

    // 替换方式3
    // var regex = /(\d{4})-(\d{2})-(\d{2})/;
    // var string = "2017-06-12";
    // var result = string.replace(regex, function (match, year, month, day) {
    //     return month + "/" + day + "/" + year;
    // });
    // console.log(result);
    // // => "06/12/2017"
})();

// 反向引用
; (function () {
    //return
    var regex = /\d{4}(-|\/|\.)\d{2}(-|\/|\.)\d{2}/;
    var string1 = "2017-06-12";
    var string2 = "2017/06/12";
    var string3 = "2017.06.12";
    var string4 = "2016-06/12"; //===>这个也对,就不符合我们的想法了
    console.log(regex.test(string1)); // true
    console.log(regex.test(string2)); // true
    console.log(regex.test(string3)); // true
    console.log(regex.test(string4)); // true


    // 针对上面的错误.
    var regex2 = /\d{4}(-|\/|\.)\d{2}\1\d{2}/;
    console.log(regex2.test(string4)); // false

    // 注意里面的 \1，表示的引用之前的那个分组 (-|\/|\.)。不管它匹配到什么（比如 -），\1 都匹配那个同
    // 样的具体某个字符。


    // ()就是一个捕获组 后面通过\1,\2,\3这种形式可以引用
    // 非捕获括号 只使用分组不让后面引用(?:xx)
})();

// 分支结构
; (function () {
    return
    // 而在多选分支结构(p1 | p2) 中，
    // 此处括号的作用也是不言而喻的，
    // 提供了分支表达式的所有可能。
    // 比如，要匹配如下的字符串
    var regex = /^I love (JavaScript|Regular Expression)$/;
    console.log(regex.test("I love JavaScript"));
    console.log(regex.test("I love Regular Expression"));
    // => true
    // => true
})();


// 测试
; (function () {
    return
    const regex = /(\d+)/;
    const str = '123abc456def';
    const result = regex.exec(str);

    if (result) {
        console.log(result[0]); // 输出 "123"  
        console.log(result[1]); // 输出 "123"  
        console.log(RegExp.$1); // 输出 "123"  
    }
})();



// 实践
; (function () {
    return
    function trim(str) {
        return str.replace(/^\s*(.*?)\s*$/g, "$1");
    }
    function trim2(str) {
        return str.replace(/^\s*(.*)\s*$/g, "$1");
    }

    let str = "  foobar   "
    console.log(trim(str).length); // 惰性算法后==>6
    console.log(trim2(str).length); // 贪心算法==>9
    console.log(str.length) // 原本是11位, 前面2个空格,后面3个空格
    console.log(str.split('')) //
    // ==> [' ', ' ', 'f', 'o','o', 'b', 'a', 'r',' ', ' ', ' ']
    console.log(trim2(str).split(''));
    // ==> ['f', 'o', 'o','b', 'a', 'r',' ', ' ', ' ']
})();